package com.pt.restaurant_backend_management.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.pt.restaurant_backend_management.common.CustomException;
import com.pt.restaurant_backend_management.pojo.dto.DishDto;
import com.pt.restaurant_backend_management.pojo.po.Category;
import com.pt.restaurant_backend_management.pojo.po.Dish;
import com.pt.restaurant_backend_management.pojo.po.DishFlavor;
import com.pt.restaurant_backend_management.mapper.CategoryMapper;
import com.pt.restaurant_backend_management.mapper.DishFlavorMapper;
import com.pt.restaurant_backend_management.mapper.DishMapper;
import com.pt.restaurant_backend_management.service.DishFlavorService;
import com.pt.restaurant_backend_management.service.DishService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.pt.restaurant_backend_management.common.R;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 菜品管理业务实现类
 * 提供菜品新增、分页查询、状态修改、删除、详情获取、更新等核心功能
 */
@Service
@Slf4j
public class DishServiceImpl extends ServiceImpl<DishMapper, Dish> implements DishService {

    @Autowired
    private DishFlavorMapper dishFlavorMapper;

    @Autowired
    private DishMapper dishMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private DishFlavorService dishFlavorService;

    /**
     * 新增菜品及其关联的口味信息
     * @param dishDto 包含菜品及口味信息的数据传输对象
     * @return 返回通用响应对象，包含操作结果信息
     */
    @Override
    @Transactional
    public R<String> saveDishWithFlavor(DishDto dishDto) {
        this.save(dishDto);

        Long dishId = dishDto.getId();

        List<DishFlavor> flavors = dishDto.getFlavors();
        for (DishFlavor flavor : flavors) {
            flavor.setDishId(dishId);
            dishFlavorMapper.insert(flavor);
        }

        return R.success("新增菜品成功！");
    }

    /**
     * 分页查询菜品信息并填充分类名称
     * @param page 当前页码
     * @param pageSize 每页显示数量
     * @param name 菜品名称（可选，用于模糊查询）
     * @return 返回包含菜品分页数据的通用响应对象
     */
    @Override
    public R<Page> pageByDish(int page, int pageSize, String name) {
        Page<Dish> pageInfo = new Page<>(page, pageSize);
        Page<DishDto> dishDtoPage = new Page<>();

        LambdaQueryWrapper<Dish> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        // 添加模糊查询条件：如果 name 不为空，则按菜品名进行 like 查询
        lambdaQueryWrapper.like(name != null, Dish::getName, name);
        lambdaQueryWrapper.orderByDesc(Dish::getUpdateTime);
        // 执行分页查询，将结果填充到 pageInfo 中
        dishMapper.selectPage(pageInfo, lambdaQueryWrapper);
        // 将 pageInfo 的属性复制到 dishDtoPage，但忽略 "records" 字段（即分页内容）
        BeanUtils.copyProperties(pageInfo, dishDtoPage, "records");

        List<Dish> records = pageInfo.getRecords();

        List<DishDto> collect = records.stream().map((item) -> {
            DishDto dishDto = new DishDto();
            BeanUtils.copyProperties(item, dishDto);
            Long categoryId = item.getCategoryId();
            // 根据分类 ID 查询分类实体
            Category category = categoryMapper.selectById(categoryId);
            // 如果分类存在，就将分类名称赋值给 DishDto
            if (category != null) {
                String categoryName = category.getName();
                dishDto.setCategoryName(categoryName);
            }

            return dishDto;
        }).collect(Collectors.toList());

        dishDtoPage.setRecords(collect);

        return R.success(dishDtoPage);
    }

    /**
     * 更新菜品及其关联的口味信息
     * @param dishDto 包含更新后的菜品及口味信息的数据传输对象
     * @return 返回通用响应对象，包含操作结果信息
     */
    @Override
    @Transactional
    public R<String> updateDishWithFlavor(DishDto dishDto) {
        this.updateById(dishDto);
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DishFlavor::getDishId, dishDto.getId());
        dishFlavorMapper.delete(queryWrapper);

        List<DishFlavor> flavors = dishDto.getFlavors();
        for (DishFlavor flavor : flavors) {
            flavor.setDishId(dishDto.getId());
            dishFlavorMapper.insert(flavor);
        }
        return R.success("修改成功！");
    }

    /**
     * 根据ID查询菜品及其对应的口味信息
     * @param id 菜品ID
     * @return 返回包含菜品及口味信息的通用响应对象
     */
    @Override
    public R<DishDto> getDishInfoById(Long id) {
        Dish dish = this.getById(id);

        DishDto dishDto = new DishDto();
        BeanUtils.copyProperties(dish, dishDto);
        // 查询口味信息
        LambdaQueryWrapper<DishFlavor> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(DishFlavor::getDishId, dish.getId());

        List<DishFlavor> flavors = dishFlavorMapper.selectList(queryWrapper);
        dishDto.setFlavors(flavors);
        return R.success(dishDto);
    }

    /**
     * 批量删除菜品及其关联的口味信息
     * @param ids 需要删除的菜品ID列表
     * @return 返回通用响应对象，包含操作结果信息
     */
    @Override
    @Transactional
    public R<String> deleteDish(List<Long> ids) {
        // 查菜品的状态，是否可以删除
        LambdaQueryWrapper<Dish> dishQueryWrapper = new LambdaQueryWrapper<>();

        dishQueryWrapper.in(Dish::getId, ids);
        dishQueryWrapper.eq(Dish::getStatus, 1);

        // 判断是否可以删除
        long count = this.count(dishQueryWrapper);
        if(count > 0) {
            throw new CustomException("菜品正在售卖中！不能删除！");
        }

        // 删除dish
        dishMapper.deleteBatchIds(ids);

        // 删除dish_flavor
        LambdaQueryWrapper<DishFlavor> dfQueryWrapper = new LambdaQueryWrapper<>();
        dfQueryWrapper.in(DishFlavor::getDishId, ids);

        dishFlavorMapper.delete(dfQueryWrapper);
        return R.success("删除菜品成功！");
    }

    /**
     * 修改菜品销售状态（起售/停售）
     * @param status 目标状态值，1表示起售，0表示停售
     * @param ids 需要修改状态的菜品ID列表
     * @return 返回通用响应对象，包含操作结果信息
     */
//    @Override
//    public R<String> sellStatus(Integer status, List<Long> ids) {
//        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.in(ids != null, Dish::getId, ids);
//        // 添加 in 查询条件：如果 ids 不为 null，则查询 id 在该列表中的菜品
//        // 第一个参数是一个布尔表达式，表示是否启用该条件。这里判断 ids != null。
//        List<Dish> list = dishMapper.selectList(queryWrapper);
//
//        for (Dish dish : list) {
//            if (dish != null) {
//                // 设置新的售卖状态（status=0 停售 / status=1 起售）
//                dish.setStatus(status);
//                dishMapper.updateById(dish);
//            }
//        }
//
//        return R.success("售卖状态修改成功");
//    }
    /**
     * 更改状态
     * @param status
     * @param ids
     */

    @Override
    @Transactional
    public void updateStatus(Integer status, List<Long> ids) {
        log.info("接收到的 ID 列表: {}", ids);//1895859846987161602
        LambdaUpdateWrapper<Dish> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(Dish::getStatus, status).in(Dish::getId, ids);
        boolean updated = this.update(updateWrapper);
        log.info("更新结果: {}", updated ? "成功" : "失败");
    }

    /**
     * 根据条件查询菜品及其关联信息（如分类名、口味等）
     * @param dish 查询条件封装对象
     * @return 返回包含菜品列表的通用响应对象
     */
    @Override
    public R<List<DishDto>> getDishInfoByCondition(Dish dish) {
        //创建 MyBatis Plus 的查询构造器 LambdaQueryWrapper，用于构建 SQL 查询条件。
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();

        //创建 MyBatis Plus 的查询构造器 LambdaQueryWrapper，用于构建 SQL 查询条件。
        queryWrapper.eq(dish.getCategoryId() != null ,Dish::getCategoryId,dish.getCategoryId());
        //添加查询条件：如果传入的 dish 对象中有 categoryId，则查询 category_id = #{categoryId} 的菜品。

        queryWrapper.eq(Dish::getStatus,1);
        //添加查询条件：查询 status = 1 的菜品。
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);
        //添加排序条件：首先按照 sort 字段升序排序，然后按照 update_time 字段降序排序。
        List<Dish> list = dishMapper.selectList(queryWrapper);
        List<DishDto> dishDtoList = list.stream().map((item) -> {
            // 使用 Java 8 的流式操作，将原始的 Dish 对象转换为 DishDto 对象。
            DishDto dishDto = new DishDto();
            BeanUtils.copyProperties(item, dishDto);
            // 将原始的 Dish 对象拷贝到 DishDto 对象中，并设置一些额外的属性。
            Long categoryId = item.getCategoryId();
            Category category = categoryMapper.selectById(categoryId);
            //根据分类 ID 查询对应的分类信息（主要是分类名称）。
            if(category != null){
                String categoryName = category.getName();
                dishDto.setCategoryName(categoryName);
            }
            //获取当前菜品的分类名称，并设置到 DishDto 对象中。
            Long dishId = item.getId();
            //获取当前菜品id
            LambdaQueryWrapper<DishFlavor> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            //创建 MyBatis Plus 的查询构造器 LambdaQueryWrapper，用于构建 SQL 查询条件。
            lambdaQueryWrapper.eq(DishFlavor::getDishId, dishId);
            //添加查询条件：查询 dish_id = #{dishId} 的口味信息。
            List<DishFlavor> dishFlavorList = dishFlavorService.list(lambdaQueryWrapper);
            dishDto.setFlavors(dishFlavorList);
            return dishDto;
        }).collect(Collectors.toList());

        return R.success(dishDtoList);
    }
}
